home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 April: Mac OS SDK / Dev.CD Apr 96 SDK / Dev.CD Apr 96 SDK1.toast / Development Kits (Disc 1) / OpenDoc Development Framework / ODFDev / ODF / Framewrk / FWPart / Sources / FWFrame.cpp < prev    next >
Encoding:
Text File  |  1995-11-08  |  58.5 KB  |  1,918 lines  |  [TEXT/MPS ]
  1. //========================================================================================
  2. //
  3. //    File:                FWFrame.cpp
  4. //    Release Version:    $ 1.0d11 $
  5. //
  6. //    Copyright:    © 1995 by Apple Computer, Inc., all rights reserved.
  7. //
  8. //========================================================================================
  9.  
  10. #include "FWFrameW.hpp"
  11.  
  12. #ifndef FWFRAME_H
  13. #include "FWFrame.h"
  14. #endif
  15.  
  16. #ifndef FWFRMINF_H
  17. #include "FWFrmInf.h"
  18. #endif
  19.  
  20. #ifndef FWPART_H
  21. #include "FWPart.h"
  22. #endif
  23.  
  24. #ifndef FWEDCMD_H
  25. #include "FWEdCmd.h"
  26. #endif
  27.  
  28. #ifndef FWPRESEN_H
  29. #include "FWPresen.h"
  30. #endif
  31.  
  32. #ifndef FWSELECT_H
  33. #include "FWSelect.h"
  34. #endif
  35.  
  36. #ifndef FWITERS_H
  37. #include "FWIters.h"
  38. #endif
  39.  
  40. #ifndef FWGADGET_H
  41. #include "FWGadget.h"
  42. #endif
  43.  
  44. #ifndef FWUTIL_H
  45. #include "FWUtil.h"
  46. #endif
  47.  
  48. #ifndef FWCLNINF_H
  49. #include "FWClnInf.h"
  50. #endif
  51.  
  52. #ifndef FWCNTRHW_H
  53. #include "FWCntrHW.h"
  54. #endif
  55.  
  56. #ifndef FWVIEWAS_H
  57. #include "FWViewAs.h"
  58. #endif
  59.  
  60. #ifndef FWPRMISE_H
  61. #include "FWPrmise.h"
  62. #endif
  63.  
  64. #ifndef FWSCLNOT_H
  65. #include "FWSclNot.h"
  66. #endif
  67.  
  68. #ifndef FWPRHDLR_H
  69. #include "FWPrHdlr.h"
  70. #endif
  71.  
  72. // ----- OS Layer -----
  73.  
  74. #ifndef FWODMISS_H
  75. #include "FWODMiss.h"
  76. #endif
  77.  
  78. #ifndef FWEVENT_H
  79. #include "FWEvent.h"
  80. #endif
  81.  
  82. #ifndef FWEVENTU_H
  83. #include "FWEventU.h"
  84. #endif
  85.  
  86. #ifndef FWMNUBAR_H
  87. #include "FWMnuBar.h"
  88. #endif
  89.  
  90. #ifndef FWODGEOM_H
  91. #include "FWODGeom.h"
  92. #endif
  93.  
  94. #ifndef FWCURSOR_H
  95. #include "FWCursor.h"
  96. #endif
  97.  
  98. #ifndef FWBARRAY_H
  99. #include "FWBArray.h"
  100. #endif
  101.  
  102. #ifndef FWGRGLOB_H
  103. #include "FWGrGlob.h"
  104. #endif
  105.  
  106. #ifndef FWGDEV_H
  107. #include "FWGDev.h"
  108. #endif
  109.  
  110. #ifndef FWMACOS_H
  111. #include "FWMacOS.h"
  112. #endif
  113.  
  114. #ifndef FWWINDOW_H
  115. #include "FWWindow.h"
  116. #endif
  117.  
  118. #if !defined(FWGRMATH_H) && defined(FW_BUILD_WIN)
  119. #include "FWGrMarh.h"
  120. #endif
  121.  
  122. // ----- OpenDoc Includes -----
  123.  
  124. #ifndef SOM_ODSession_xh
  125. #include <ODSessn.xh>
  126. #endif
  127.  
  128. #ifndef SOM_ODArbitrator_xh
  129. #include <Arbitrat.xh>
  130. #endif
  131.  
  132. #ifndef SOM_Module_OpenDoc_Commands_defined
  133. #include <CmdDefs.xh>
  134. #endif
  135.  
  136. #ifndef SOM_ODStorageUnitView_xh
  137. #include <SUView.xh>
  138. #endif
  139.  
  140. #ifndef SOM_ODClipboard_xh
  141. #include <Clipbd.xh>
  142. #endif
  143.  
  144. #ifndef SOM_Module_OpenDoc_StdProps_defined
  145. #include <StdProps.xh>
  146. #endif
  147.  
  148. #ifndef SOM_Module_OpenDoc_StdTypes_defined
  149. #include <StdTypes.xh>
  150. #endif
  151.  
  152. //========================================================================================
  153. // RunTime Info
  154. //========================================================================================
  155.  
  156. #if FW_LIB_EXPORT_PRAGMAS
  157. #pragma lib_export on
  158. #endif
  159.  
  160. #ifdef FW_BUILD_MAC
  161. #pragma segment FW_FrameSegment
  162. #endif
  163.  
  164. FW_DEFINE_CLASS_M3(FW_CFrame, FW_CView, FW_MDragDroppable, FW_MIdle);
  165.  
  166. //========================================================================================
  167. //    class FW_CFrame
  168. //========================================================================================
  169.  
  170. //----------------------------------------------------------------------------------------
  171. //    FW_CFrame::FW_CFrame
  172. //----------------------------------------------------------------------------------------
  173.  
  174. FW_CFrame::FW_CFrame(Environment *ev,
  175.                     ODFrame* odFrame, 
  176.                     FW_CPresentation* presentation, 
  177.                     FW_CPart* part) :
  178.     FW_MDragDroppable(ev, part),
  179.     FW_CView(ev),        
  180.     FW_MIdle(part, this),
  181.     fPart(part),
  182.     fContentView(NULL),
  183.     fGetFrontClicks(TRUE),
  184.     fActiveFacet(NULL),
  185.     fCanBeActiveFrame(TRUE),
  186.     fFocusSet(ev, part->GetSession(ev)),
  187.     fChangedFocusSet(ev, part->GetSession(ev)),
  188.     fFocusSetChanged(FALSE),
  189.     fNeedsFoci(FALSE),
  190.     fPresentation(presentation),
  191.     fWindow(NULL),
  192.     fFacetCount(0),
  193.     fODFrame(odFrame),
  194.     fPreviousViewType(odFrame->GetViewType(ev)),
  195.     fViewAs(NULL),
  196.     fConnection(NULL),
  197.     fViewUnderCursor(NULL),
  198.     fScrollingViews(NULL),
  199.     fContentViewLocation(FW_kZeroPoint)
  200. #ifdef FW_BUILD_WIN
  201.     ,fShadowWindow(NULL)
  202. #endif
  203. {
  204.     FW_ASSERT(fODFrame);
  205.     
  206.     fTarget = this;
  207.     
  208.     this->SetNextEventHandler(ev, part);
  209.  
  210.     fNeedsFoci = odFrame->IsRoot(ev);
  211.     
  212.     // ----- By default we put all of them
  213.     // Note: If the containing window is a floating window I will remove
  214.     // them in facet added.
  215.     fFocusSet.Add(ev, FW_CPart::gKeyFocusToken);
  216.     fFocusSet.Add(ev, FW_CPart::gMenuFocusToken);
  217.     fFocusSet.Add(ev, FW_CPart::gSelectionFocusToken);
  218.     fFocusSet.Add(ev, FW_CPart::gClipboardFocusToken);
  219.             
  220.     SetIdentifier(ev, fPresentation->GetPresentationType(ev));
  221.     
  222.     // ----- force to be view as frame if root -----
  223.     if (fPreviousViewType != FW_CPart::gViewAsFrameToken && IsRoot(ev))
  224.         fODFrame->SetViewType(ev, FW_CPart::gViewAsFrameToken);
  225.  
  226.     // ----- Set the frame's view Bounds to its shape bounds
  227.     FW_CRect frameRect;
  228.     PrivGetFrameShapeBounds(ev, frameRect);
  229.     PrivSetBounds(ev, frameRect);
  230.     PrivSetExtent(ev, frameRect.Size());    
  231.  
  232.     // ----- By default the frame is equal to its ContentView
  233.     PrivSetIsContentView(ev, TRUE);
  234.     fContentView = (FW_CView*)this;
  235. }
  236.  
  237. //----------------------------------------------------------------------------------------
  238. //    FW_CFrame::~FW_CFrame
  239. //----------------------------------------------------------------------------------------
  240.  
  241. FW_CFrame::~FW_CFrame()
  242. {
  243.     Environment* ev = somGetGlobalEnvironment();
  244.     
  245.     FW_ASSERT(IsRegisteredForIdle(ev) == FALSE);
  246.  
  247.     FW_ASSERT(fWindow == NULL);    // should have been deleted in FrameRemoved
  248.     
  249.     if (fViewAs && fPresentation)
  250.         fPresentation->ReleaseViewAs(ev, fViewAs);
  251.  
  252.     if (fConnection) {
  253.         fConnection->RemoveAllInterests();    // [LSD] necessary?
  254.         delete fConnection;
  255.         fConnection = NULL;
  256.     }
  257.     
  258.     // deletes its ContentView first to make sure that the scroller is deleted before
  259.     // the scrollbars (otherwise ~FW_CView deletes views in reverse order of creation)
  260.     if (IsContentView(ev) == FALSE)    {
  261.         delete GetContentView(ev);
  262.     }
  263.     
  264.     if (fScrollingViews) {
  265.         delete fScrollingViews;
  266.         fScrollingViews = NULL;
  267.     }
  268. }
  269.  
  270. //----------------------------------------------------------------------------------------
  271. //    FW_CFrame::PrivCreateWindow
  272. //----------------------------------------------------------------------------------------
  273.  
  274. FW_CWindow* FW_CFrame::PrivCreateWindow(Environment* ev, ODWindow* odWindow)
  275. {
  276.     FW_ASSERT(odWindow);
  277.     FW_ASSERT(fWindow == NULL || fWindow->GetID(ev) == odWindow->GetID(ev));
  278.     
  279.     if (fWindow == NULL)
  280.     {
  281.         ODPlatformWindow platformWindow = odWindow->GetPlatformWindow(ev);
  282.         
  283.         FW_CWindow* fwWindow = NULL;
  284.         
  285.         if (IsRoot(ev))
  286.         {
  287. #ifdef FW_BUILD_MAC
  288.             fwWindow = (FW_CWindow*) ::GetWRefCon(platformWindow);
  289. #endif
  290.  
  291. #ifdef FW_BUILD_WIN
  292.             fwWindow = (FW_CWindow*) ::GetProp(platformWindow, "ODF:Window");
  293. #endif
  294.         }
  295.         
  296.         if (fwWindow != NULL)
  297.             fWindow = fwWindow;
  298.         else
  299.             fWindow = new FW_CWindow(ev, fPart->GetODPart(ev), odWindow->GetID(ev));
  300.     }
  301.  
  302.     return fWindow;
  303. }
  304.  
  305. //----------------------------------------------------------------------------------------
  306. //    FW_CFrame::FrameRemoved
  307. //----------------------------------------------------------------------------------------
  308. // Notification
  309.  
  310. void FW_CFrame::FrameRemoved(Environment* ev, FW_Boolean toStorage)
  311. {
  312. FW_UNUSED(toStorage);
  313.  
  314.     if (toStorage)
  315.         UnregisterIdle(ev);
  316.         
  317.     // ----- Relinquish what ever focus we have
  318.     fFocusSet.RelinquishFocusSet(ev, GetODFrame(ev));
  319.         
  320.     // ----- Check that the window has been deleted -----
  321.     FW_ASSERT(fFacetCount == 0);    
  322.     FW_ASSERT(fWindow == NULL);    // When the frame is removed it should not have any facets. fWindow
  323.                                 // should already be null (see FacetRemoved)
  324.  
  325.     // ----- delete the partInfo -----
  326.     FW_CFramePartInfo* framePartInfo = (FW_CFramePartInfo*)fODFrame->GetPartInfo(ev);
  327.     fODFrame->SetPartInfo(ev, NULL);
  328.     delete framePartInfo;
  329.  
  330.     fPresentation->PrivRemoveFrame(ev, this);
  331. }
  332.  
  333. //----------------------------------------------------------------------------------------
  334. //    FW_CFrame::FrameAdded
  335. //----------------------------------------------------------------------------------------
  336. // Notification
  337.  
  338. void FW_CFrame::FrameAdded(Environment* ev, FW_Boolean fromStorage)
  339. {
  340. FW_UNUSED(ev);
  341. FW_UNUSED(fromStorage);
  342.     
  343.     // ----- Add it to the presentation -----
  344.     fPresentation->PrivAddFrame(ev, this);
  345.     
  346.     // ----- Initialize printing handler -----
  347.     FW_CPrintHandler* printHandler = NewPrintHandler(ev);
  348.     if (printHandler != NULL)
  349.         AdoptEventHandler(ev, printHandler);
  350. }
  351.  
  352. //----------------------------------------------------------------------------------------
  353. //    FW_CFrame::PageEmbeddedFrames
  354. //----------------------------------------------------------------------------------------
  355.  
  356. void FW_CFrame::PageEmbeddedFrames(Environment* ev)
  357. {
  358.     // Doesn't do anything because not embedding
  359. }
  360.  
  361. //----------------------------------------------------------------------------------------
  362. //    FW_CFrame::GetODStorageUnitID
  363. //----------------------------------------------------------------------------------------
  364.  
  365. ODStorageUnitID FW_CFrame::GetODStorageUnitID(Environment* ev) const
  366. {
  367.     ODStorageUnit* storageUnit = fODFrame->GetStorageUnit(ev);
  368.     
  369.     return storageUnit != NULL ? storageUnit->GetID(ev) : kODNULLID;
  370. }
  371.  
  372. //----------------------------------------------------------------------------------------
  373. // FW_CFrame::GetTarget
  374. //----------------------------------------------------------------------------------------
  375.  
  376. FW_MEventHandler* FW_CFrame::GetTarget(Environment* ev) const
  377. {
  378.     return fTarget;
  379. }
  380.  
  381. //----------------------------------------------------------------------------------------
  382. // FW_CFrame::SetTarget
  383. //----------------------------------------------------------------------------------------
  384.  
  385. void FW_CFrame::SetTarget(Environment* ev, FW_MEventHandler* theTarget)
  386. {
  387.     fTarget = theTarget;
  388. }
  389.  
  390. //----------------------------------------------------------------------------------------
  391. // FW_CFrame::WantsToBeTarget
  392. //----------------------------------------------------------------------------------------
  393.  
  394. FW_Boolean FW_CFrame::WantsToBeTarget(Environment* ev)
  395. {
  396.     return TRUE;
  397. }
  398.  
  399. //----------------------------------------------------------------------------------------
  400. //    FW_CFrame::HandleMenu
  401. //----------------------------------------------------------------------------------------
  402.  
  403. FW_Boolean FW_CFrame::HandleMenu(Environment* ev, const FW_CMenuEvent& theMenuEvent)
  404. {
  405.     FW_Boolean result = TRUE;
  406.     FW_CEditCommand* cmd;
  407.     ODCommandID commandID = theMenuEvent.GetCommandID(ev);
  408.     
  409.     switch (commandID)
  410.     {
  411.         case kODCommandViewAsWin:
  412.             fPresentation->ViewInWindow(ev, this, NULL);
  413.             break;
  414.         
  415.         case kODCommandCut:
  416.         case kODCommandCopy:
  417.         case kODCommandPaste:
  418.         case kODCommandPasteAs:
  419.         case kODCommandClear:
  420.             cmd = this->NewEditCommand(ev, commandID);
  421.             if (cmd)
  422.                 GetPart(ev)->ExecuteCommand(ev, cmd);
  423.             break;
  424.                         
  425.         case kODCommandSelectAll:
  426.             FW_CSelection* selection = fPresentation->GetSelection(ev);
  427.             if (selection)
  428.                 selection->SelectAll(ev);
  429.             break;
  430.             
  431.         default:
  432.             result = FW_CView::HandleMenu(ev, theMenuEvent);    
  433.     }
  434.     
  435.     return result;
  436. }
  437.  
  438. //----------------------------------------------------------------------------------------
  439. //    FW_CFrame::SetDragging
  440. //----------------------------------------------------------------------------------------
  441.  
  442. void FW_CFrame::SetDragging(Environment* ev, FW_Boolean dragging)
  443. {
  444.     fODFrame->SetDragging(ev, dragging);
  445. }
  446.  
  447. //----------------------------------------------------------------------------------------
  448. //    FW_CFrame::SetDroppable
  449. //----------------------------------------------------------------------------------------
  450.  
  451. void FW_CFrame::SetDroppable(Environment* ev, FW_Boolean droppable)
  452. {
  453.     fODFrame->SetDroppable(ev, droppable);
  454. }
  455.  
  456. //----------------------------------------------------------------------------------------
  457. //    FW_CFrame::NewPartWindow
  458. //----------------------------------------------------------------------------------------
  459.  
  460. FW_CWindow* FW_CFrame::NewPartWindow(Environment* ev, ODFacet* sourceFacet)
  461. {
  462.     FW_CRect frameBounds = GetBounds(ev);
  463.     FW_CAcquiredODTransform transform = sourceFacet->AcquireWindowFrameTransform(ev, NULL);
  464.     frameBounds.Transform(ev, transform);
  465.     GetWindow(ev)->WindowToScreen(ev, frameBounds);
  466.     frameBounds.Offset(FW_IntToFixed(20), FW_IntToFixed(20));
  467.     
  468.     FW_CString255 partName;
  469.     fPart->GetPartName(ev, partName);
  470.     
  471.     return new FW_CWindow(ev, 
  472.                         fPart->GetODPart(ev),
  473.                         fODFrame,
  474.                         FALSE,                            // persistent frame
  475.                         FW_CPart::gViewAsFrameToken,
  476.                         GetPresentation(ev)->GetPresentationType(ev),
  477.                         partName,
  478.                         frameBounds.Size(),
  479.                         frameBounds.TopLeft(),
  480.                         FW_kDocumentWindow);
  481. }
  482.  
  483. //----------------------------------------------------------------------------------------
  484. //    FW_CFrame::NewEditCommand
  485. //----------------------------------------------------------------------------------------
  486.  
  487. FW_CEditCommand* FW_CFrame::NewEditCommand(Environment* ev, ODCommandID commandID)
  488. {
  489.     return FW_NEW(FW_CEditCommand, (ev,
  490.                                     commandID,
  491.                                     this,
  492.                                     FW_kCantUndo));
  493. }
  494.  
  495. //----------------------------------------------------------------------------------------
  496. //    FW_CFrame::InstallMenus
  497. //----------------------------------------------------------------------------------------
  498. //     By default call the part with a null menuBar
  499.  
  500. void FW_CFrame::InstallMenus(Environment *ev)
  501. {
  502.     GetPart(ev)->InstallMenus(ev, NULL);    // will install the part menubar
  503. }
  504.  
  505. #ifdef FW_BUILD_MAC
  506. //----------------------------------------------------------------------------------------
  507. //    FW_CFrame::HandleWindowEvent
  508. //----------------------------------------------------------------------------------------
  509.  
  510. FW_Boolean FW_CFrame::HandleWindowEvent(Environment* ev, const FW_CMacWindowEvent& windowEvent)
  511. {
  512.     FW_Boolean handled = TRUE;
  513.     
  514.     unsigned long message = windowEvent.GetMessage();
  515.     switch (windowEvent.GetMessage())
  516.     {
  517.         case inZoomIn:
  518.         case inZoomOut:
  519.             {    
  520.                 ODPlatformWindow platformWindow = GetWindow(ev)->GetPlatformWindow(ev);
  521.                 
  522.                 // ----- Get the size of the window border -----
  523.                 FW_CRect borderSize;
  524.                 FW_CWindow::PrivGetBorderSize(platformWindow, borderSize);
  525.                 
  526.                 // ----- Find out where the window would like to be zoomed out to 
  527.                 FW_CRect screenRect;
  528.                 ::FW_MacGetMaxIntersectedDevice(platformWindow, screenRect);
  529.                 screenRect.Inset(FW_IntToFixed(3), FW_IntToFixed(3));    // leave space around window structure area
  530.             
  531.                 // ----- call the part to get a custom size (interior size) -----
  532.                 FW_CPoint proposedSize(screenRect.Width() - borderSize.left - borderSize.right, 
  533.                                        screenRect.Height() - borderSize.top - borderSize.bottom);
  534.                 this->AdjustZoomedWindowSize(ev, proposedSize);
  535.                 
  536.                 fWindow->PrivMacDoZoom(ev, proposedSize, borderSize, screenRect, message);
  537.             }
  538.             break;
  539.         
  540.         case inGrow:
  541.             {
  542.                 FW_CRect growLimits(FW_IntToFixed(64), FW_IntToFixed(64), FW_IntToFixed(32000), FW_IntToFixed(32000));
  543.                 this->AdjustWindowGrowLimits(ev, growLimits[FW_kTopLeft], growLimits[FW_kBotRight]);
  544.                 
  545.                 // If minimum is lareger than maximun then do something
  546.                 if (growLimits.left > growLimits.right)
  547.                     growLimits.left = growLimits.right;
  548.                 if (growLimits.top > growLimits.bottom)
  549.                     growLimits.top = growLimits.bottom;
  550.                     
  551.                 fWindow->PrivMacTrackResizeWindow(ev, growLimits, windowEvent);
  552.             }
  553.             break;
  554.  
  555.         case inGoAway:
  556.              if (fWindow->IsFloating(ev)) 
  557.                 fWindow->Hide(ev);
  558.             else
  559.                 handled = FALSE;
  560.             break;
  561.             
  562.         default:
  563.             handled = FALSE;
  564.     }
  565.     
  566.     return handled;
  567. }
  568. #endif
  569.  
  570. //----------------------------------------------------------------------------------------
  571. // FW_CFrame::AdjustZoomedWindowSize
  572. //----------------------------------------------------------------------------------------
  573. //    proposedSize is the interior size of the window
  574.  
  575. void FW_CFrame::AdjustZoomedWindowSize(Environment *ev, FW_CPoint& proposedSize)
  576. {
  577. }
  578.  
  579. //----------------------------------------------------------------------------------------
  580. // FW_CFrame::AdjustWindowGrowLimits
  581. //----------------------------------------------------------------------------------------
  582. //    proposedSize is the interior size of the window
  583.  
  584. void FW_CFrame::AdjustWindowGrowLimits(Environment *ev, FW_CPoint& minSize, FW_CPoint& maxSize)
  585. {
  586. }
  587.  
  588. //----------------------------------------------------------------------------------------
  589. //    FW_CFrame::HandleAdjustMenus
  590. //----------------------------------------------------------------------------------------
  591.  
  592. FW_Boolean FW_CFrame::HandleAdjustMenus(Environment *ev, FW_CMenuBar* menuBar, 
  593.                                     FW_Boolean hasMenuFocus, FW_Boolean isRoot)
  594. {
  595.     if (hasMenuFocus)
  596.     {
  597.         // ----- Only if I am the target -----
  598.         if (GetTarget(ev) == this)
  599.         {
  600.             FW_CSelection* selection = fPresentation->GetSelection(ev);
  601.             FW_Boolean hasSelection = selection && !selection->IsEmpty(ev);
  602.         
  603.             // ----- Edit Menu -----
  604.             // If read only clear, cut past items will be disabled in FW_CPart::HandleAdjustMenus
  605.             menuBar->EnableCommand(ev, kODCommandClear, hasSelection);
  606.             menuBar->EnableCommand(ev, kODCommandCut, hasSelection);
  607.             menuBar->EnableCommand(ev, kODCommandCopy, hasSelection);
  608.             menuBar->EnableCommand(ev, kODCommandPaste, FALSE);
  609.             
  610.             menuBar->EnableCommand(ev, kODCommandPasteAs, HasPropertyOnClipboard(ev, kODPropLinkSpec, kODLinkSpec));
  611.         }
  612.         
  613.         menuBar->EnableCommand(ev, kODCommandViewAsWin, !IsTopFrame(ev));
  614.     }
  615.     
  616.     return FW_CView::HandleAdjustMenus(ev, menuBar, hasMenuFocus, isRoot);
  617. }
  618.  
  619. //----------------------------------------------------------------------------------------
  620. //    FW_CFrame::IsTopFrame
  621. //----------------------------------------------------------------------------------------
  622. //    IsTopFrame returns true if this frame is a sub-frame of the root frame
  623.  
  624. FW_Boolean FW_CFrame::IsTopFrame(Environment *ev) const
  625. {
  626.     if (IsRoot(ev))
  627.         return TRUE;
  628.     
  629.     return IsSubframe(ev) && AcquireContainingFrame(ev)->IsRoot(ev);
  630. }
  631.  
  632. //----------------------------------------------------------------------------------------
  633. //    FW_CFrame::IsSiblingFrameOf
  634. //----------------------------------------------------------------------------------------
  635.  
  636. FW_Boolean FW_CFrame::IsSiblingFrameOf(Environment *ev, ODFrame* otherODFrame) const
  637. {
  638.     if (otherODFrame == NULL)
  639.         return FALSE;
  640.         
  641.     FW_CAcquiredODPart otherPart = otherODFrame->AcquirePart(ev);
  642.     if (GetODPart(ev) == otherPart)
  643.     {
  644.         FW_CFrame* otherFrame = FW_CFrame::ODtoFWFrame(ev, otherODFrame);
  645.         return GetPresentation(ev) == otherFrame->GetPresentation(ev);
  646.     }
  647.     
  648.     return FALSE;
  649. }
  650.  
  651. //----------------------------------------------------------------------------------------
  652. //    FW_CFrame::FocusStateChanged
  653. //----------------------------------------------------------------------------------------
  654. //    When overridden, call inherited::FocusStateChanged FIRST
  655.  
  656. void FW_CFrame::FocusStateChanged(Environment *ev, ODTypeToken focus, FW_Boolean newState, ODFrame* newOwner)
  657. {
  658.     if (focus == FW_CPart::gSelectionFocusToken)
  659.     {
  660.         if (!newState)
  661.         {
  662. /*    [HLX] we have a bug in ODF. If I close the selection when I get deactivated I can't clear it anymore
  663. during a drag&drop. The dropped frame actives itself before I have time to clear the selection
  664.             //     Close the selection if I become deactive and the newOwner is not NULL and
  665.             //    not one of my sibling
  666.             FW_CSelection* selection = fPresentation->GetSelection(ev);
  667.             if (selection)
  668.             {
  669.                 if (newOwner != NULL && !IsSiblingFrameOf(ev, newOwner))
  670.                     selection->CloseSelection(ev);
  671.             }
  672. */
  673.             Deactivate(ev);
  674.         }
  675.         else
  676.         {
  677.             Activate(ev);
  678.         }
  679.         
  680.         fPart->SetActiveFrame(ev, newState ? this : NULL);
  681.     }
  682.     else if (focus == FW_CPart::gMenuFocusToken)
  683.     {
  684.         if (newState)
  685.         {
  686.             InstallMenus(ev);
  687.             fPart->HideShowFloatingWindows(ev, TRUE);
  688.         }
  689.     }
  690. }
  691.  
  692. //----------------------------------------------------------------------------------------
  693. //     FW_CFrame::Activate
  694. //----------------------------------------------------------------------------------------
  695.  
  696. FW_Boolean FW_CFrame::Activate(Environment* ev)
  697. {
  698.     FW_Boolean result = FW_CView::Activate(ev);
  699.     
  700.     // *LSD this part to review: which SubView should become target.
  701.     //  Should have saved a target at the last deactivate.
  702.     if (result && this->IsEnabled(ev) && this->WantsToBeTarget(ev))
  703.         this->BecomeTarget(ev);
  704.     
  705.     return result;
  706. }
  707.  
  708. //----------------------------------------------------------------------------------------
  709. //     FW_CFrame::ActivateFrame
  710. //----------------------------------------------------------------------------------------
  711.  
  712. void FW_CFrame::ActivateFrame(Environment *ev, ODFacet* activatedFacet)
  713. { 
  714.     if (CanBeActiveFrame(ev))
  715.     {
  716.         SetActiveFacet(ev, activatedFacet);
  717.         
  718.         if (!IsActive(ev))
  719.         {
  720.             // ----- Check first if the FocusSet has been changed -----
  721.             if (fFocusSetChanged)
  722.             {
  723.                 fFocusSet = fChangedFocusSet;
  724.                 fFocusSetChanged = FALSE;
  725.             }
  726.             
  727.             // ----- Our version of RequestFocusSet returns false if the focus set is empty
  728.             if (fFocusSet.RequestFocusSet(ev, GetODFrame(ev)))
  729.             {
  730.                 fNeedsFoci = FALSE;
  731.                 
  732.                 FW_CFocusSetIterator ite(ev, fFocusSet);
  733.                 for (ODTypeToken token = ite.First(ev); ite.IsNotComplete(ev); token = ite.Next(ev))
  734.                     FocusStateChanged(ev, token, TRUE, NULL);            
  735.             }
  736.         }
  737.     }
  738. }
  739.  
  740. //----------------------------------------------------------------------------------------
  741. //    FW_CFrame::CanBeActiveFrame
  742. //----------------------------------------------------------------------------------------
  743.  
  744. FW_Boolean FW_CFrame::CanBeActiveFrame(Environment* ev) const
  745. {
  746.     FW_ASSERT(GetWindow(ev) != NULL);
  747.     return fCanBeActiveFrame && !GetWindow(ev)->IsFloating(ev);
  748. }
  749.  
  750. //----------------------------------------------------------------------------------------
  751. //    FW_CFrame::PrivGetFrameShapeBounds
  752. //----------------------------------------------------------------------------------------
  753.  
  754. void FW_CFrame::PrivGetFrameShapeBounds(Environment* ev, FW_CRect& rect) const
  755. {
  756.     FW_CAcquiredODShape aqODShape = AcquireFrameShape(ev, NULL);
  757.     rect = FW_GetShapeBoundingBox(ev, aqODShape);
  758. }
  759.  
  760. //----------------------------------------------------------------------------------------
  761. //    FW_CFrame::ODtoFWFrame
  762. //----------------------------------------------------------------------------------------
  763.  
  764. FW_CFrame* FW_CFrame::ODtoFWFrame(Environment *ev, ODFrame* odFrame)
  765. {
  766.     FW_CFrame* frame = NULL;
  767.     
  768.     if (odFrame)
  769.     {
  770.         FW_CFramePartInfo* framePartInfo = (FW_CFramePartInfo*)odFrame->GetPartInfo(ev);
  771.         FW_ASSERT(framePartInfo != NULL);
  772.         frame = framePartInfo->GetFrame();
  773.     }
  774.     
  775.     return frame;
  776. }
  777.  
  778. //----------------------------------------------------------------------------------------
  779. //     FW_CFrame::FrameShapeChanged
  780. //----------------------------------------------------------------------------------------
  781. //    When overridden, call inherited::FrameShapeChanged
  782.  
  783. void FW_CFrame::FrameShapeChanged(Environment* ev)
  784. {
  785.     FW_CRect frameRect;
  786.     PrivGetFrameShapeBounds(ev, frameRect);
  787.     SetSize(ev, frameRect.Size());
  788.     SetExtent(ev, frameRect.Size());  // *LSD: ok?
  789.     
  790.     if (GetViewType(ev) == FW_CPart::gViewAsFrameToken)
  791.     {
  792. #ifdef FW_BUILD_WIN
  793.         MoveSizeShadowWindow(ev);
  794. #endif
  795.         AdjustSubViews(ev);
  796.     }
  797.     
  798.     UpdateUsedAndActiveShapes(ev);
  799. }
  800.  
  801. //----------------------------------------------------------------------------------------
  802. //    FW_CFrame::SetActiveFacet
  803. //----------------------------------------------------------------------------------------
  804.  
  805. void FW_CFrame::SetActiveFacet(Environment* ev, ODFacet*  activeFacet)
  806. {
  807.     fActiveFacet = activeFacet;
  808. }
  809.  
  810. //----------------------------------------------------------------------------------------
  811. //    FW_CFrame::UpdateUsedAndActiveShapes
  812. //----------------------------------------------------------------------------------------
  813.  
  814. void FW_CFrame::UpdateUsedAndActiveShapes(Environment* ev)
  815. {
  816.     // ----- Used Shape -----
  817.     UpdateUsedShape(ev);
  818.  
  819.     // ----- Active Shape for everyone of my facets -----
  820.     FW_CFrameFacetIterator iter(ev, this);
  821.     for (ODFacet* facet = iter.First(ev); iter.IsNotComplete(ev); facet = iter.Next(ev))
  822.     {
  823.         UpdateActiveShape(ev, facet);
  824.     }
  825. }
  826.  
  827. //----------------------------------------------------------------------------------------
  828. //    FW_CFrame::UpdateUsedShape
  829. //----------------------------------------------------------------------------------------
  830.  
  831. void FW_CFrame::UpdateUsedShape(Environment* ev)
  832. {
  833.     // ----- Used Shape -----
  834.     FW_CAcquiredODShape aqUsedShape;
  835.     
  836.     if (fViewAs == NULL)
  837.     {
  838.         //    ----- By default the used shape is the frame shape
  839.         FW_CAcquiredODShape aqFrameShape = FW_CopyAndRelease(ev, AcquireFrameShape(ev, NULL));
  840.         aqUsedShape = AdjustUsedShape(ev, aqFrameShape);
  841.     }
  842.     else
  843.     {
  844.         aqUsedShape = fViewAs->CalcUsedShape(ev);            
  845.     }
  846.     
  847.     ChangeUsedShape(ev, aqUsedShape, NULL);    // Passing NULL is valid
  848. }
  849.  
  850. //----------------------------------------------------------------------------------------
  851. //    FW_CFrame::UpdateActiveShape
  852. //----------------------------------------------------------------------------------------
  853.  
  854. void FW_CFrame::UpdateActiveShape(Environment* ev, ODFacet* facet)
  855. {
  856.     FW_CAcquiredODShape aqActiveShape;
  857.     FW_CAcquiredODShape aqProposedActiveShape = FW_CopyAndRelease(ev, AcquireUsedShape(ev));
  858.     
  859.     if (fViewAs == NULL) 
  860.         aqActiveShape = AdjustActiveShape(ev, facet, aqProposedActiveShape);
  861.     else
  862.         aqActiveShape = aqProposedActiveShape;
  863.         
  864.     facet->ChangeActiveShape(ev, aqActiveShape, NULL);    
  865. }
  866.  
  867. //----------------------------------------------------------------------------------------
  868. //    FW_CFrame::AdjustUsedShape
  869. //----------------------------------------------------------------------------------------
  870. //    suggestedUsedShape is the frame shape. The default implementation returns NULL because
  871. //    we don't want to maintain an used shape
  872.  
  873. ODShape* FW_CFrame::AdjustUsedShape(Environment* ev, ODShape* suggestedUsedShape)
  874. {
  875.     return NULL;
  876. }
  877.  
  878. //----------------------------------------------------------------------------------------
  879. //    FW_CFrame::AdjustActiveShape
  880. //----------------------------------------------------------------------------------------
  881. //    suggestedActiveShape is the used shape. The default implementation returns NULL because
  882. //    we don't want to maintain an active shape
  883.  
  884. ODShape* FW_CFrame::AdjustActiveShape(Environment* ev, ODFacet* facet, ODShape* suggestedActiveShape)
  885. {
  886.     return NULL;
  887. }
  888.  
  889. //----------------------------------------------------------------------------------------
  890. //    FW_CFrame::SetFocusSet
  891. //----------------------------------------------------------------------------------------
  892. // We have to use a temporary focusSet because if the focus set is changed while the frame 
  893. // is active and relinquishFocus is called (like in FrameRemoved) it will be called 
  894. // with the wrong focus set
  895.  
  896. void FW_CFrame::SetFocusSet(Environment* ev, const FW_CFocusSet& focusSet)
  897. {
  898.     fFocusSetChanged = TRUE;
  899.     fChangedFocusSet = focusSet;
  900.     
  901.     // ----- [HLX] bug in OpenDoc ???
  902.     if (IsRoot(ev))
  903.     {
  904.         if (!fChangedFocusSet.Contains(ev, FW_CPart::gSelectionFocusToken))
  905.             fChangedFocusSet.Add(ev, FW_CPart::gSelectionFocusToken);
  906.     }
  907. }
  908.  
  909. //----------------------------------------------------------------------------------------
  910. //     FW_CFrame::FacetPartInfoFactory
  911. //----------------------------------------------------------------------------------------
  912.  
  913. FW_CFacetPartInfo* FW_CFrame::FacetPartInfoFactory(Environment* ev, ODFacet* facet)
  914. {
  915.     FW_CFacetPartInfo* facetPartInfo = new FW_CFacetPartInfo;
  916.     facetPartInfo->InitFacetPartInfo(ev, facet);
  917.     return facetPartInfo;
  918. }
  919.  
  920. //----------------------------------------------------------------------------------------
  921. //    FW_CFrame::RequestFrameShape
  922. //----------------------------------------------------------------------------------------
  923.  
  924. FW_Boolean FW_CFrame::RequestFrameShape(Environment *ev, ODShape* shape, ODCanvas* biasCanvas)
  925. {
  926.     FW_CAcquiredODShape aqOldFrameShape = FW_CopyAndRelease(ev, AcquireFrameShape(ev, biasCanvas));
  927.     
  928.     FW_CAcquiredODShape aqNewFrameShape = fODFrame->RequestFrameShape(ev, shape, biasCanvas);
  929.     
  930.     FW_Boolean changed = !aqNewFrameShape->IsSameAs(ev, aqOldFrameShape);
  931.     
  932.     if (changed)
  933.         FrameShapeChanged(ev); 
  934.     
  935.     return changed;
  936. }
  937.  
  938. //----------------------------------------------------------------------------------------
  939. //     FW_CFrame::FacetAdded
  940. //----------------------------------------------------------------------------------------
  941. //    When overridden call inherited::FacetAdded FIRST
  942.  
  943. void FW_CFrame::FacetAdded(Environment* ev, ODFacet* facet)
  944. {        
  945.     // ----- Install the newest facet as the active facet of this frame
  946.     this->SetActiveFacet(ev, facet);
  947.     
  948.     // ----- Set the facet's part info -----
  949.     FW_CFacetPartInfo *facetInfo = FacetPartInfoFactory(ev, facet);
  950.     facet->SetPartInfo(ev, (ODInfoType)facetInfo);
  951.  
  952.     // ----- Create the window wrapper -----
  953.     // ----- We have to wait for facet added because 
  954.     // ----- at FrameAdded it it too early
  955.     FW_CAcquiredODWindow aqODWindow = fODFrame->AcquireWindow(ev);
  956.     this->PrivCreateWindow(ev, aqODWindow);    // Might not create a FW_CWindow if already has one    
  957.  
  958.     // ----- If the Window is a floating window: remove all the foci by
  959.     // ------ setting an empty set.
  960.     if (aqODWindow->IsFloating(ev))
  961.     {
  962.         FW_CFocusSet focusSet(ev, fPart->GetSession(ev));
  963.         SetFocusSet(ev, focusSet);    
  964.     }
  965.     
  966.     // ----- Create the Shadow Window for Windows
  967. #ifdef FW_BUILD_WIN
  968.     CreateShadowWindow(ev);
  969. #endif    
  970.  
  971.     // ----- First facet: update used shape and create the sub-views
  972.     if(fFacetCount == 0)
  973.     {
  974.         UpdateUsedShape(ev);
  975.         
  976.         //FW_CGadgetInitializer vi(ev);    *LSD  replace it with CViewInitializer?
  977.         CreateSubViews(ev);
  978.     }
  979.  
  980.     // ----- Give my frame a chance to update the active shape of the facet -----
  981.     UpdateActiveShape(ev, facet);
  982.     
  983.     // ----- One more facet -----
  984.     fFacetCount++;
  985.     
  986.     // ----- Finally invalidate the content of the facet so it will be redrawn -----
  987.     FW_CAcquiredODShape aqUsedShape = AcquireUsedShape(ev); 
  988.     facet->Invalidate(ev, aqUsedShape, NULL);
  989. }
  990.  
  991. //----------------------------------------------------------------------------------------
  992. //     FW_CFrame::FacetRemoved
  993. //----------------------------------------------------------------------------------------
  994. //    When overridden call inherited::FacetRemoved last
  995.  
  996. void FW_CFrame::FacetRemoved(Environment* ev, ODFacet* odFacet)
  997. {
  998.     FW_ASSERT(fFacetCount > 0);
  999.     
  1000.     if (this->GetActiveFacet(ev) == odFacet)
  1001.     {
  1002.         FW_CFrameFacetIterator iter(ev, this);
  1003.         this->SetActiveFacet(ev, iter.First(ev));
  1004.     }
  1005.     
  1006.     // ----- Delete the facet part info -----
  1007.     FW_CFacetPartInfo* partInfo = FW_CFacetPartInfo::GetFacetPartInfo(ev, odFacet);
  1008.     delete partInfo;
  1009.     odFacet->SetPartInfo(ev, (ODInfoType)NULL);
  1010.     
  1011.     // ----- One less facet -----
  1012.     fFacetCount--;
  1013.     
  1014.     // ----- Delete the fWindow if it was the last facet -----
  1015.     if (fFacetCount == 0)
  1016.     {
  1017.         FW_ASSERT(fWindow);
  1018.         delete fWindow;
  1019.         fWindow = NULL;
  1020.     }
  1021. }
  1022.  
  1023. //----------------------------------------------------------------------------------------
  1024. //    FW_CFrame::GetWindow
  1025. //----------------------------------------------------------------------------------------
  1026.  
  1027. FW_CWindow* FW_CFrame::GetWindow(Environment* ev) const
  1028. {
  1029.     return fWindow;
  1030. }
  1031.  
  1032. //----------------------------------------------------------------------------------------
  1033. //    FW_CFrame::PrivAttachSourceFrame
  1034. //----------------------------------------------------------------------------------------
  1035. // PrivAttachSourceFrame is not called if 'sourceFrame' is NULL
  1036.  
  1037. void FW_CFrame::PrivAttachSourceFrame(Environment* ev, FW_CFrame* sourceFrame)
  1038. {
  1039. FW_UNUSED(sourceFrame);
  1040.     
  1041.     FW_ASSERT(sourceFrame != NULL);    
  1042.     FW_ASSERT(fPresentation == sourceFrame->GetPresentation(ev));
  1043. }
  1044.  
  1045. //----------------------------------------------------------------------------------------
  1046. //    FW_CFrame::HasSelectionFocus()
  1047. //----------------------------------------------------------------------------------------
  1048.  
  1049. FW_Boolean FW_CFrame::HasSelectionFocus(Environment* ev) const
  1050. {    
  1051.     FW_CAcquiredODFrame aqODFrame = fPart->GetSession(ev)->GetArbitrator(ev)->AcquireFocusOwner(ev, FW_CPart::gSelectionFocusToken);
  1052.     return fODFrame == aqODFrame;
  1053. }
  1054.  
  1055. //----------------------------------------------------------------------------------------
  1056. //    FW_CFrame::ViewTypeChanged
  1057. //----------------------------------------------------------------------------------------
  1058.  
  1059. void FW_CFrame::ViewTypeChanged(Environment* ev, 
  1060.                                 ODTypeToken newViewType, 
  1061.                                 ODTypeToken oldViewType)
  1062. {
  1063.     Invalidate(ev);
  1064.     
  1065.     if (fViewAs != NULL)
  1066.         fPresentation->ReleaseViewAs(ev, fViewAs);
  1067.     fViewAs = NULL;
  1068.     
  1069.     if (newViewType != FW_CPart::gViewAsFrameToken)
  1070.         fViewAs = fPresentation->AcquireViewAs(ev, this, newViewType);
  1071.         
  1072.     UpdateUsedAndActiveShapes(ev);
  1073.     
  1074.     Invalidate(ev);
  1075. }
  1076.  
  1077. //----------------------------------------------------------------------------------------
  1078. //    FW_CFrame::BuildThumbnail
  1079. //----------------------------------------------------------------------------------------
  1080. //    By default does nothing
  1081.  
  1082. void FW_CFrame::BuildThumbnail(Environment* ev, FW_CGraphicContext& gc, const FW_CRect& destRect)
  1083. {
  1084. }
  1085.  
  1086. //----------------------------------------------------------------------------------------
  1087. //    FW_CFrame::PresentationChanged()
  1088. //----------------------------------------------------------------------------------------
  1089.  
  1090. void FW_CFrame::PresentationChanged(Environment* ev)
  1091. {    
  1092. //    SetIdentifier(ev, GetPresentation(ev));
  1093. }
  1094.  
  1095. //----------------------------------------------------------------------------------------
  1096. //    FW_CFrame::SequenceChanged()
  1097. //----------------------------------------------------------------------------------------
  1098.  
  1099. void FW_CFrame::SequenceChanged(Environment* ev)
  1100. {    
  1101. }
  1102.  
  1103. //----------------------------------------------------------------------------------------
  1104. //     FW_CFrame::PrivActiveWindowOnMouseDown
  1105. //----------------------------------------------------------------------------------------
  1106.  
  1107. FW_Boolean FW_CFrame::PrivActiveWindowOnMouseDown(Environment* ev, ODFacet* facet, FW_Boolean clickedInFrame)
  1108. {
  1109.     if (!GetWindow(ev)->IsFloating(ev))
  1110.     {
  1111.         FW_Boolean windowUnselected = !GetWindow(ev)->IsActive(ev);
  1112.         
  1113.         // ----- Select the window if not already selected -----
  1114.         if (windowUnselected)
  1115.             GetWindow(ev)->Select(ev);        
  1116.         
  1117.         // ----- active frame on mousedown only if clicked in the frame -----
  1118.         if (clickedInFrame)
  1119.             ActivateFrame(ev, facet);
  1120.         
  1121.         // ----- If the window was unselected and I don't want the ----- 
  1122.         // ----- first click just return TRUE;
  1123.         if (windowUnselected && !GetFrontClicks(ev))
  1124.                 return TRUE;
  1125.     }
  1126.     
  1127.     return FALSE;
  1128. }
  1129.  
  1130. //----------------------------------------------------------------------------------------
  1131. //    FW_CFrame::HandleActivateEvent
  1132. //----------------------------------------------------------------------------------------
  1133.  
  1134. FW_Boolean FW_CFrame::HandleActivateEvent(Environment* ev, const FW_CActivateEvent& theActivateEvent)
  1135. {
  1136.     if (theActivateEvent.IsActivating(ev))
  1137.     {
  1138.         if (fNeedsFoci) 
  1139.             ActivateFrame(ev, theActivateEvent.GetFacet(ev));
  1140.     }
  1141.     else
  1142.     {
  1143.         fNeedsFoci = IsActive(ev);
  1144.     }
  1145.     
  1146.     return FW_CView::HandleActivateEvent(ev, theActivateEvent);
  1147. }
  1148.  
  1149. //----------------------------------------------------------------------------------------
  1150. //    FW_CFrame::HandleSuspendResumeEvent
  1151. //----------------------------------------------------------------------------------------
  1152.  
  1153. FW_Boolean FW_CFrame::HandleSuspendResumeEvent(Environment* ev, const FW_CSuspendResumeEvent& theResumeSuspendEvent)
  1154. {
  1155.     if (IsRoot(ev))
  1156.     {
  1157.         // ----- We have to test that this frame belongs to the part with the menu focus
  1158.         ODArbitrator* arbitrator =  fPart->GetSession(ev)->GetArbitrator(ev);
  1159.         FW_CAcquiredODFrame aqODFrame = arbitrator->AcquireFocusOwner(ev, FW_CPart::gMenuFocusToken);
  1160.  
  1161.         if (aqODFrame != NULL)
  1162.         {
  1163.             FW_CAcquiredODPart aqODPart = aqODFrame->AcquirePart(ev);
  1164.             if (aqODPart == fPart->GetODPart(ev))
  1165.                 // ----- Won't do anything if window is not a floating window -----
  1166.                 GetWindow(ev)->HideShowOnActivate(ev, !theResumeSuspendEvent.IsGoingToBackground(ev));            
  1167.         }
  1168.         
  1169.     }
  1170.     
  1171.     return FW_CView::HandleSuspendResumeEvent(ev, theResumeSuspendEvent);
  1172. }
  1173.  
  1174. //----------------------------------------------------------------------------------------
  1175. //    FW_CFrame::GeometryChanged
  1176. //----------------------------------------------------------------------------------------
  1177. //    the geometry (clip shape or external transform) of one of my facet or one of my
  1178. //    embedding facet as changed
  1179.  
  1180. void FW_CFrame::GeometryChanged(Environment *ev,
  1181.                                 ODFacet* odFacet,
  1182.                                 FW_Boolean clipShapeChanged,
  1183.                                 FW_Boolean externalTransformChanged)
  1184. {
  1185. FW_UNUSED(ev);
  1186. FW_UNUSED(odFacet);
  1187. FW_UNUSED(clipShapeChanged);
  1188. FW_UNUSED(externalTransformChanged);
  1189.  
  1190. #ifdef FW_BUILD_WIN
  1191.     MoveSizeShadowWindow(ev);
  1192. #endif
  1193. }
  1194.  
  1195. //----------------------------------------------------------------------------------------
  1196. //    FW_CFrame::OpenSelection
  1197. //----------------------------------------------------------------------------------------
  1198.  
  1199. void FW_CFrame::OpenSelection(Environment* ev)
  1200. {
  1201.     // Nothing to do
  1202. }
  1203.  
  1204. //----------------------------------------------------------------------------------------
  1205. //    FW_CFrame::HandleDraw
  1206. //----------------------------------------------------------------------------------------
  1207.  
  1208. void FW_CFrame::HandleDraw(Environment *ev, ODFacet* odFacet, ODShape* invalidShape)
  1209. {
  1210.     //     if the facet doesn't have a graphicdevice it is not one of my facet anymore
  1211.     //    That means that FacetRemoved has been called but my container is still trying
  1212.     //    do draw me.[HLX] Might be a bug in OpenDoc. Might have been fixed in DR4
  1213.     if (FW_CFacetPartInfo::GetFacetGraphicDevice(ev, odFacet) == NULL)
  1214.         return;
  1215.         
  1216. //    FW_CAcquiredODShape aqInvalidShape(invalidShape->Copy(ev));
  1217.  
  1218. //    // InvalidShape is in frame coordinate. Tranform it to content coordinate
  1219. //    FW_CAcquiredODTransform aqTransform = AcquireInternalTransform(ev, NULL);    
  1220. //    aqInvalidShape->InverseTransform(ev, aqTransform);
  1221.  
  1222. #ifdef FW_BUILD_WIN
  1223.     // [HLX] bug in windows? the invalidShape is in pixels instead of points
  1224.     aqInvalidShape->Outset(ev, ff(1));    // [HLX] Because of rounding errors
  1225.     FW_CGraphicDevice *device = FW_CFacetPartInfo::GetFacetGraphicDevice(ev, odFacet);
  1226.     device->PixelToPoint(ev, aqInvalidShape);
  1227. #endif
  1228.     
  1229.     // ATTENTION: we don't test fViewAs != NULL because if the frame was created
  1230.     //    as an icon or thumbnail it may not yet have a fViewAs
  1231.     ODTypeToken viewType = GetViewType(ev);
  1232.     if (viewType == FW_CPart::gViewAsFrameToken)
  1233.     {
  1234.         FW_CView::HandleDraw(ev, odFacet, invalidShape);
  1235.     }
  1236.     else
  1237.     {
  1238.         if (fViewAs == NULL)
  1239.             fViewAs = fPresentation->AcquireViewAs(ev, this, viewType);
  1240.                 
  1241.         fViewAs->Draw(ev, odFacet, invalidShape /*aqInvalidShape*/);
  1242.     }
  1243. }
  1244.  
  1245. //----------------------------------------------------------------------------------------
  1246. //    FW_CFrame::Draw
  1247. //----------------------------------------------------------------------------------------
  1248. // invalidShape is in content coordinate
  1249.  
  1250. void FW_CFrame::Draw(Environment *ev, ODFacet* odFacet, ODShape* invalidShape)
  1251. {
  1252. FW_UNUSED(odFacet);
  1253. FW_UNUSED(invalidShape);
  1254.  
  1255. }
  1256.  
  1257. //----------------------------------------------------------------------------------------
  1258. //    FW_CFrame::HandleMouseEnter
  1259. //----------------------------------------------------------------------------------------
  1260. // where is in frame coordinate
  1261.  
  1262. FW_Boolean FW_CFrame::HandleMouseEnter(Environment *ev, ODFacet* odFacet, const FW_CPoint& where)
  1263. {
  1264.     fViewUnderCursor = GetViewContaining(ev, odFacet, where);
  1265.     FW_ASSERT(fViewUnderCursor != NULL);
  1266.  
  1267.     if (!fViewUnderCursor->AdjustCursor(ev, odFacet, where))
  1268.         FW_gArrowCursor.Select();
  1269.  
  1270.     return fViewUnderCursor->DoMouseEnter(ev, odFacet, where);
  1271. }
  1272.  
  1273. //----------------------------------------------------------------------------------------
  1274. //    FW_CFrame::HandleMouseLeave
  1275. //----------------------------------------------------------------------------------------
  1276.  
  1277. FW_Boolean FW_CFrame::HandleMouseLeave(Environment *ev, ODFacet* odFacet)
  1278. {
  1279.     FW_gArrowCursor.Select();
  1280.     
  1281.     FW_ASSERT(fViewUnderCursor != NULL);
  1282.     
  1283.     FW_Boolean result = fViewUnderCursor->DoMouseLeave(ev, odFacet);
  1284.  
  1285.     fViewUnderCursor = NULL;
  1286.     
  1287.     return result;
  1288. }
  1289.  
  1290. //----------------------------------------------------------------------------------------
  1291. //    FW_CFrame::HandleMouseWithin
  1292. //----------------------------------------------------------------------------------------
  1293. // where is in frame coordinate
  1294.  
  1295. FW_Boolean FW_CFrame::HandleMouseWithin(Environment *ev, ODFacet* odFacet, const FW_CPoint& theMousePoint)
  1296. {
  1297.     FW_CView* viewUnderCursor = GetViewContaining(ev, odFacet, theMousePoint);
  1298.     FW_ASSERT(viewUnderCursor != NULL);
  1299.     
  1300.     FW_ASSERT(fViewUnderCursor != NULL);
  1301.     
  1302.     if (viewUnderCursor != fViewUnderCursor)
  1303.     {
  1304.         fViewUnderCursor->DoMouseLeave(ev, odFacet);
  1305.         
  1306.         viewUnderCursor->DoMouseEnter(ev, odFacet, theMousePoint);
  1307.     }
  1308.     else
  1309.         viewUnderCursor->DoMouseWithin(ev, odFacet, theMousePoint);
  1310.         
  1311.     fViewUnderCursor = viewUnderCursor;
  1312.     
  1313.     if (!fViewUnderCursor->AdjustCursor(ev, odFacet, theMousePoint))
  1314.         FW_gArrowCursor.Select();
  1315.         
  1316.     return TRUE;
  1317. }
  1318.  
  1319. //----------------------------------------------------------------------------------------
  1320. //    FW_CFrame::AdjustCursor
  1321. //----------------------------------------------------------------------------------------
  1322. // where is in frame coordinate
  1323.  
  1324. FW_Boolean FW_CFrame::AdjustCursor(Environment *ev, ODFacet* odFacet, const FW_CPoint& theMousePoint)
  1325. {
  1326.     return FALSE;
  1327. }
  1328.  
  1329. //----------------------------------------------------------------------------------------
  1330. //    FW_CFrame::GetODPart()
  1331. //----------------------------------------------------------------------------------------
  1332.  
  1333. ODPart* FW_CFrame::GetODPart(Environment* ev) const
  1334. {
  1335.     return fPart->GetODPart(ev);
  1336. }
  1337.  
  1338. //----------------------------------------------------------------------------------------
  1339. //    FW_CFrame::ExternalizeFrame
  1340. //----------------------------------------------------------------------------------------
  1341. // When overriding call inherited first
  1342.  
  1343. void FW_CFrame::ExternalizeFrame(Environment* ev, ODStorageUnitView* storageUnitView)
  1344. {
  1345.     FW_CByteArray byteArray(&fContentViewLocation, sizeof(FW_CPoint));
  1346.     storageUnitView->SetValue(ev, byteArray);
  1347. }
  1348.  
  1349. //----------------------------------------------------------------------------------------
  1350. //    FW_CFrame::InternalizeFrame
  1351. //----------------------------------------------------------------------------------------
  1352. // When overriding call inherited first
  1353.  
  1354. void FW_CFrame::InternalizeFrame(Environment* ev, ODStorageUnitView* storageUnitView)
  1355. {
  1356.     FW_CByteArray byteArray;
  1357.     storageUnitView->GetValue(ev, sizeof(FW_CPoint), byteArray);
  1358.     byteArray.CopyBuffer(&fContentViewLocation, sizeof(FW_CPoint));
  1359. }
  1360.  
  1361. //----------------------------------------------------------------------------------------
  1362. //    FW_CFrame::SetContentView()
  1363. //----------------------------------------------------------------------------------------
  1364.  
  1365. void FW_CFrame::SetContentView(Environment* ev, FW_CView* view) 
  1366. {
  1367.     // SetContentView can only be called once to set fContentView
  1368.     // (fContentView was initialized to the frame itself)
  1369.     FW_ASSERT(IsContentView(ev) == TRUE);
  1370.     
  1371.     PrivSetIsContentView(ev, FALSE);
  1372.     fContentView = view;
  1373.  
  1374.     // Move the internal transform to be relative to the new ContentView
  1375.     FW_CAcquiredODTransform aqTransform = AcquireInternalTransform(ev, NULL);
  1376.     
  1377.     // ----- Remove the previous position -----
  1378.     FW_CPoint offset = -fContentViewLocation; 
  1379.     aqTransform->MoveBy(ev, (ODPoint*)&offset);
  1380.      
  1381.     FW_CAcquiredODTransform aqViewToFrameTransform(view->AcquireViewToFrameTransform(ev));
  1382.     aqTransform->PostCompose(ev, aqViewToFrameTransform);    
  1383.     
  1384.     ChangeInternalTransform(ev, aqTransform);
  1385.     
  1386.     PrivContentViewLocationChanged(ev);
  1387. }
  1388.  
  1389. //----------------------------------------------------------------------------------------
  1390. //    FW_CFrame::GetContentExtent
  1391. //----------------------------------------------------------------------------------------
  1392.  
  1393. void FW_CFrame::GetContentExtent(Environment* ev, FW_CPoint& extent) const
  1394. {
  1395.     extent = GetContentView(ev)->GetExtent(ev);
  1396. }
  1397.  
  1398. //----------------------------------------------------------------------------------------
  1399. //    FW_CFrame::AcquireContentShape
  1400. //----------------------------------------------------------------------------------------
  1401. //    return the content shape in Frame coordinates
  1402.  
  1403. ODShape* FW_CFrame::AcquireContentShape(Environment *ev)
  1404. {    
  1405.     FW_CView* contentView = GetContentView(ev);
  1406.     
  1407.     FW_CRect contentRect(contentView->GetBounds(ev));
  1408.     contentRect.Place(FW_kFixed0, FW_kFixed0);
  1409.     
  1410.     contentView->ViewToFrame(ev, contentRect);
  1411.     return FW_NewODShape(ev, contentRect);
  1412. }
  1413.  
  1414. //----------------------------------------------------------------------------------------
  1415. // FW_CFrame::AddScrollingView
  1416. //----------------------------------------------------------------------------------------
  1417.  
  1418. void FW_CFrame::AddScrollingView(Environment* ev, const FW_CView *view)
  1419. {
  1420.     FW_ASSERT(view->UseContentSpaceInX(ev) || view->UseContentSpaceInY(ev));
  1421.     
  1422.     if (fScrollingViews == NULL) {
  1423.         fScrollingViews = new FW_CPrivOrderedCollection;
  1424.     } 
  1425.     else {
  1426.         FW_ASSERT(fScrollingViews->Contains(this) == FALSE);    
  1427.     }
  1428.     
  1429.     fScrollingViews->AddLast((FW_CView*) view);
  1430. }
  1431.  
  1432. //----------------------------------------------------------------------------------------
  1433. // FW_CFrame::RemoveScrollingView
  1434. //----------------------------------------------------------------------------------------
  1435.  
  1436. void FW_CFrame::RemoveScrollingView(Environment* ev, const FW_CView *view)
  1437. {
  1438.     // fScrollingViews is already NULL when frame is being deleted
  1439.     if(fScrollingViews != NULL) {
  1440.         FW_ASSERT(fScrollingViews->Contains((FW_CView*)view));
  1441.         fScrollingViews->Remove((FW_CView*)view);
  1442.     }
  1443. }
  1444.  
  1445. //----------------------------------------------------------------------------------------
  1446. // FW_CFrame::AcquireContentScrollShape
  1447. //----------------------------------------------------------------------------------------
  1448. // This returns the shape (in Frame coord.) composed of the ContentView + all the views
  1449. // scrolling in X or Y with the content.  
  1450. // [LSD] if scroll is not purely X or Y we limit the shape to the ContentView for now.
  1451. //         Other views will have to scroll independantly
  1452.  
  1453. ODShape* FW_CFrame::AcquireContentScrollShape(Environment* ev, const FW_CPoint& by)
  1454. {
  1455.     // Get the contentView first
  1456.     ODShape* scrollShape = ::FW_NewODShape(ev, FW_CRect(FW_kZeroPoint, fContentView->GetSize(ev)));
  1457.     fContentView->ViewToFrame(ev, scrollShape);
  1458.  
  1459.     if (by.IntX() == 0 || by.IntY() == 0) {
  1460.         FW_Boolean verticalScroll = (by.IntX() == 0);
  1461.         FW_CScrollingViewIterator ite(ev, this);
  1462.         for (FW_CView* subview = ite.First(ev); ite.IsNotComplete(ev);  subview = ite.Next(ev))
  1463.         {
  1464.             if (subview->IsVisible(ev))
  1465.             {
  1466.                 if ((verticalScroll && subview->UseContentSpaceInX(ev)) ||
  1467.                     (!verticalScroll && subview->UseContentSpaceInY(ev))) continue;
  1468.                 
  1469.                 FW_CAcquiredODShape aqScrollShape = ::FW_NewODShape(ev, FW_CRect(FW_kZeroPoint, subview->GetSize(ev)));
  1470.                 subview->ViewToFrame(ev, aqScrollShape);
  1471.                 
  1472.                 scrollShape->Union(ev, aqScrollShape);
  1473.             }
  1474.         }
  1475.     }    
  1476.     
  1477.     return scrollShape;
  1478. }
  1479.  
  1480. //----------------------------------------------------------------------------------------
  1481. //    FW_CFrame::PrivReleaseODFrame
  1482. //----------------------------------------------------------------------------------------
  1483.  
  1484. void FW_CFrame::PrivReleaseODFrame(Environment *ev)
  1485. {
  1486.     FW_ASSERT(fODFrame != NULL);
  1487.     fODFrame->Release(ev);
  1488.     fODFrame = NULL;
  1489. }
  1490.  
  1491. //----------------------------------------------------------------------------------------
  1492. //    FW_CFrame::BeginRelinquishFocus
  1493. //----------------------------------------------------------------------------------------
  1494.  
  1495. FW_Boolean FW_CFrame::BeginRelinquishFocus(Environment *ev, ODTypeToken focus, ODFrame* proposedFrame)
  1496. {
  1497.     return TRUE;
  1498. }
  1499.  
  1500. //----------------------------------------------------------------------------------------
  1501. //    FW_CFrame::AbortRelinquishFocus
  1502. //----------------------------------------------------------------------------------------
  1503.  
  1504. void FW_CFrame::AbortRelinquishFocus(Environment *ev, ODTypeToken focus, ODFrame* proposedFrame)
  1505. {
  1506. }
  1507.  
  1508. //---------------------------------------------------------------------------------------
  1509. //    FW_CFrame::CommitRelinquishFocus
  1510. //---------------------------------------------------------------------------------------
  1511.  
  1512. void FW_CFrame::CommitRelinquishFocus(Environment *ev,
  1513.                                         ODTypeToken focus,
  1514.                                         ODFrame* proposedFrame)
  1515. {
  1516.     FocusStateChanged(ev, focus, FALSE, proposedFrame);
  1517.         
  1518.     FW_Boolean doIt = (proposedFrame == NULL);
  1519.     if (!doIt)
  1520.     {
  1521.         FW_CAcquiredODPart aqODPart = proposedFrame->AcquirePart(ev);
  1522.         doIt = aqODPart != fPart->GetODPart(ev);
  1523.     }
  1524.     
  1525.     if (doIt)
  1526.     {    
  1527.         if (focus == FW_CPart::gMenuFocusToken)
  1528.             fPart->HideShowFloatingWindows(ev, FALSE);
  1529.     }
  1530. }
  1531.  
  1532. //----------------------------------------------------------------------------------------
  1533. //    FW_CFrame::ClonePartInfo
  1534. //----------------------------------------------------------------------------------------
  1535.  
  1536. void FW_CFrame::ClonePartInfo(Environment* ev, 
  1537.                             ODDraftKey key,
  1538.                             ODInfoType partInfo,
  1539.                             ODStorageUnitView* storageUnitView,
  1540.                             ODFrame* scope)
  1541. {
  1542.     // Don't do anything for now
  1543. }
  1544.  
  1545. //----------------------------------------------------------------------------------------
  1546. //    FW_CFrame::AddConnection
  1547. //----------------------------------------------------------------------------------------
  1548.  
  1549. void FW_CFrame::AddConnection(Environment*ev, FW_CInterest& interest)
  1550. {
  1551.     if (fConnection == NULL) {
  1552.         fConnection = new FW_CHandleFunctionConnection(this);
  1553.         fConnection->Connect();
  1554.     }
  1555.     
  1556.     fConnection->AddInterest(interest);
  1557. }
  1558.  
  1559. //----------------------------------------------------------------------------------------
  1560. //    FW_CFrame::HandleNotification
  1561. //----------------------------------------------------------------------------------------
  1562.  
  1563. void FW_CFrame::HandleNotification(const FW_CNotification& notification)
  1564. {
  1565.     // *LSD: check that we're dealing only with scrolling
  1566.     Environment *ev = somGetGlobalEnvironment();
  1567.     ODSession* session = GetFrame(ev)->GetPart(ev)->GetSession(ev);
  1568.     ODTypeToken scrollNotificationToken = session->Tokenize(ev, FW_CScrollNotification::kName);
  1569.     
  1570.     if (notification.GetName() != scrollNotificationToken) {
  1571.         return;
  1572.     }
  1573.     
  1574.     const FW_CScrollNotification& scrollNfy = (FW_CScrollNotification&) notification;
  1575.     
  1576.     // Set scrollBy to opposite value of scrolling to move the internal transform
  1577.     FW_CPoint scrollBy;
  1578.     
  1579.     if (scrollNfy.GetDirection() == FW_CScrollNotification::kVertical)
  1580.         scrollBy.Set(FW_kFixed0, -scrollNfy.GetDelta());
  1581.     else
  1582.         scrollBy.Set(-scrollNfy.GetDelta(), FW_kFixed0);
  1583.     
  1584.     FW_CAcquiredODTransform aqTransform = AcquireInternalTransform(ev, NULL);
  1585.     ODPoint odScrollBy = scrollBy;
  1586.     aqTransform->MoveBy(ev, &odScrollBy);
  1587.  
  1588.     // *LSD2  hack can be removed after DR4 ?
  1589. #ifdef FW_BUILD_MAC
  1590.     // [HLX] Temporary because of a bug in OpenDoc
  1591.     //    ChangeInternalTransform changes the clip and the origin and does not restore it
  1592.     GrafPtr port;
  1593.     ::GetPort(&port);    
  1594.     Point origin;
  1595.     origin.h = port->portRect.left;
  1596.     origin.v = port->portRect.top;
  1597.     ODRgnHandle clipRgn = ::NewRgn();
  1598.     ::GetClip(clipRgn);
  1599. #endif
  1600.  
  1601.     ChangeInternalTransform(ev, aqTransform);
  1602.     
  1603. #ifdef FW_BUILD_MAC
  1604.     // [HLX] Temporary because of a bug in OpenDoc
  1605.     ::SetPort(port);
  1606.     ::SetClip(clipRgn);
  1607.     ::DisposeRgn(clipRgn);
  1608.     ::SetOrigin(-origin.h, -origin.v);
  1609. #endif
  1610.  
  1611.     // ----- Invalid view cached transforms -----
  1612.     PrivInvalidateCachedTransforms(ev);
  1613. }
  1614.  
  1615. #ifdef FW_BUILD_WIN
  1616. //----------------------------------------------------------------------------------------
  1617. //    FW_CFrame::CreateShadowWindow
  1618. //----------------------------------------------------------------------------------------
  1619. // Create a transparent Window so that we get a chance to handle messages sent by Windows
  1620. // controls to their parent Window.
  1621.  
  1622. void FW_CFrame::CreateShadowWindow(Environment *ev)
  1623. {
  1624.     ODPlatformWindow parentHWnd = fWindow->GetPlatformWindow(ev);
  1625. #ifdef FW_BUILD_WIN16
  1626.     HINSTANCE hInstance = (HINSTANCE)GetWindowWord(parentHWnd, GWW_HINSTANCE);
  1627. #endif
  1628. #ifdef FW_BUILD_WIN32
  1629.     HINSTANCE hInstance = (HINSTANCE)GetWindowLong(parentHWnd, GWL_HINSTANCE);
  1630. #endif
  1631.     
  1632.     WNDCLASS wc;
  1633.     
  1634.     if (!GetClassInfo(hInstance, "ShadowWindow", &wc))
  1635.     {
  1636.         wc.style = CS_DBLCLKS;
  1637.         wc.lpfnWndProc = ShadowWindowProc;
  1638.         wc.cbClsExtra = 0;
  1639.         wc.cbWndExtra = 4;
  1640.         wc.hInstance = hInstance;
  1641.         wc.hIcon = NULL;
  1642.         wc.hCursor = LoadCursor(NULL, IDC_ARROW);
  1643.         wc.hbrBackground = NULL;
  1644.         wc.lpszMenuName = NULL;
  1645.         wc.lpszClassName = "ShadowWindow";
  1646.         
  1647.         if (!RegisterClass(&wc))
  1648.             return;
  1649.     }
  1650.     
  1651.     fShadowWindow = CreateWindowEx(WS_EX_TRANSPARENT, "ShadowWindow", "",
  1652.                                    WS_CHILD | WS_VISIBLE, 0, 0, 0, 0,
  1653.                                    parentHWnd, NULL, hInstance, (LPSTR) this);
  1654.     MoveSizeShadowWindow(ev);
  1655. }
  1656. #endif
  1657.  
  1658. #ifdef FW_BUILD_WIN
  1659. //----------------------------------------------------------------------------------------
  1660. //    FW_CFrame::MoveSizeShadowWindow
  1661. //----------------------------------------------------------------------------------------
  1662.  
  1663. void FW_CFrame::MoveSizeShadowWindow(Environment* ev)
  1664. {
  1665.     if (fShadowWindow != NULL)
  1666.     {
  1667.         ODFacet* facet = GetActiveFacet(ev);
  1668.         FW_CAcquiredODShape aqShape(FW_CopyAndRelease(ev, facet->AcquireActiveShape(ev, NULL)));
  1669.         FW_CAcquiredODTransform aqExternalTransform = facet->AcquireExternalTransform(ev, NULL);
  1670.         aqShape->Transform(ev, aqExternalTransform);
  1671.         
  1672.         FW_CRect bBox;
  1673.         aqShape->GetBoundingBox(ev, &bBox);
  1674.         
  1675.         // Shape bounding box is in 72dpi, need to convert to pixels
  1676.         if(!IsRoot(ev))
  1677.         {
  1678.             // [KVV] ??? This is only necessary for non-root frames
  1679.         
  1680.             HDC hDC = ::GetDC(NULL);
  1681.             int xRes = ::GetDeviceCaps(hDC, LOGPIXELSX);
  1682.             int yRes = ::GetDeviceCaps(hDC, LOGPIXELSY);
  1683.             ::ReleaseDC(NULL, hDC);
  1684.             
  1685.             FW_Fixed xScale = FW_FixDiv(ff(xRes), ff(72));
  1686.             FW_Fixed yScale = FW_FixDiv(ff(yRes), ff(72));
  1687.             
  1688.             bBox.left     = FW_FixMul(bBox.left,    xScale);
  1689.             bBox.top     = FW_FixMul(bBox.top,    yScale);
  1690.             bBox.right     = FW_FixMul(bBox.right,    xScale);
  1691.             bBox.bottom    = FW_FixMul(bBox.bottom,yScale);
  1692.         }
  1693.         
  1694.         FW_PlatformRect wndRect;
  1695.         bBox.AsPlatformRect(wndRect);
  1696.         
  1697.         ::MoveWindow(fShadowWindow, wndRect.left, wndRect.top,
  1698.                        wndRect.right - wndRect.left, wndRect.bottom - wndRect.top, TRUE);
  1699.     }
  1700. }
  1701. #endif
  1702.  
  1703. #ifdef FW_BUILD_WIN
  1704. //----------------------------------------------------------------------------------------
  1705. //    FW_CFrame::ShadowWindowProc
  1706. //----------------------------------------------------------------------------------------
  1707.  
  1708. LRESULT CALLBACK FW_CFrame::ShadowWindowProc(HWND hWnd, UINT msg,
  1709.                                              WPARAM wParam, LPARAM lParam)
  1710. {
  1711.     switch (msg)
  1712.     {
  1713. #ifdef FW_DEBUG
  1714.         // ----- Frame the shadow window for ease of debugging
  1715.         case WM_PAINT:
  1716.             {
  1717.                 PAINTSTRUCT ps;
  1718.                 HDC hDC = ::BeginPaint(hWnd, &ps);
  1719.                 
  1720.                 if(::GetPrivateProfileInt("Debug", "ShadowWindow Outline", FALSE, "ODF.ini"))
  1721.                 {
  1722.                     static const char pattern[8][2] = 
  1723.                     {
  1724.                         { 0xAA, 0x00 },
  1725.                         { 0x55, 0x00 },
  1726.                         { 0xAA, 0x00 },
  1727.                         { 0x55, 0x00 },
  1728.                         { 0xAA, 0x00 },
  1729.                         { 0x55, 0x00 },
  1730.                         { 0xAA, 0x00 },
  1731.                         { 0x55, 0x00 }
  1732.                     };
  1733.                     
  1734.                     HBITMAP hBitmap = ::CreateBitmap(8, 8, 1, 1, pattern);
  1735.     
  1736.                     HBRUSH hBrush = ::CreatePatternBrush(hBitmap);
  1737.     
  1738.                     ::SetTextColor(hDC, RGB(0xFF, 0x00, 0xFF));
  1739.                     
  1740.                     RECT rc;
  1741.                     ::GetClientRect(hWnd, &rc);
  1742.                     
  1743.                     HRGN hRgn = ::CreateRectRgnIndirect(&rc);
  1744.                     
  1745.                     ::FrameRgn(hDC, hRgn, hBrush, 3, 3);
  1746.                     
  1747.                     ::DeleteObject(hRgn);
  1748.                     ::DeleteObject(hBrush);
  1749.                     ::DeleteObject(hBitmap);
  1750.                 }
  1751.  
  1752.                 ::EndPaint(hWnd, &ps);
  1753.             }
  1754.             return 0;
  1755. #endif
  1756.  
  1757.         case WM_CREATE:
  1758.             SetWindowLong(hWnd, 0, (long) ((LPCREATESTRUCT) lParam)->lpCreateParams);
  1759.             return 0;
  1760.             
  1761.         case WM_NCHITTEST:
  1762.             return HTTRANSPARENT;
  1763.             
  1764.         case WM_COMMAND:
  1765.             switch (HIWORD(wParam))
  1766.             {
  1767.                 case BN_CLICKED:
  1768.                     {
  1769.                         HWND hButton = HWND(lParam);
  1770.                         
  1771.                         // If this is a window
  1772.                         if (hButton != NULL && ::IsWindow(hButton))
  1773.                         {
  1774.                             // Get the scroll bar helper
  1775.                             FW_CPrivWinButtonHelper* buttonHelper =
  1776.                                 FW_DYNAMIC_CAST(FW_CPrivWinButtonHelper, FW_CPrivWinControlHelper::HWNDToHelper(hButton));
  1777.         
  1778.                             // Tell the button to update itself and the pane
  1779.                             buttonHelper->HandleButtonMessage();
  1780.                             return 0L;
  1781.                         }
  1782.                     }
  1783.                     break;
  1784.             }
  1785.             break;
  1786.             
  1787.         case WM_HSCROLL:
  1788.         case WM_VSCROLL:
  1789.             {
  1790.                 HWND hBar = HWND(lParam);
  1791.  
  1792.                 // If this is not a scroll bar control, but a Windows
  1793.                 // window scroll bar, pass it to Windows wndproc
  1794.                 if (hBar == NULL)
  1795.                 {
  1796.                     FW_DEBUG_MESSAGE("Warning: ODF does not use Window scroll bars!");
  1797.                     break;
  1798.                 }
  1799.  
  1800.                 // If this is a window
  1801.                 if (hBar != NULL && ::IsWindow(hBar))
  1802.                 {
  1803.                     // Get the scroll bar helper
  1804.                     FW_CPrivWinScrollBarHelper* sbHelper =
  1805.                         FW_DYNAMIC_CAST(FW_CPrivWinScrollBarHelper, FW_CPrivWinControlHelper::HWNDToHelper(hBar));
  1806.  
  1807.                     // Tell the scroll bar to update itself and the pane
  1808.                     if (sbHelper != NULL)
  1809.                     {
  1810.                         sbHelper->HandleScrollMessage(LOWORD(wParam), HIWORD(wParam));
  1811.                         return 0L;
  1812.                     }
  1813.                 }
  1814.                 break;
  1815.             }
  1816.     }
  1817.     
  1818.     return DefWindowProc(hWnd, msg, wParam, lParam);
  1819. }
  1820. #endif
  1821.  
  1822. //----------------------------------------------------------------------------------------
  1823. //    FW_CFrame::HasPropertyOnClipboard
  1824. //----------------------------------------------------------------------------------------
  1825.  
  1826. FW_Boolean FW_CFrame::HasPropertyOnClipboard(Environment* ev, ODPropertyName propertyName, ODValueType type)
  1827. {
  1828.     ODSession* session = GetPart(ev)->GetSession(ev);
  1829.     ODArbitrator* arbitrator = session->GetArbitrator(ev);
  1830.     FW_CAcquiredODFrame aqODFrame = arbitrator->AcquireFocusOwner(ev, FW_CPart::gClipboardFocusToken);
  1831.     
  1832.     if ((aqODFrame == fODFrame) || (arbitrator->RequestFocus(ev, FW_CPart::gClipboardFocusToken, fODFrame)) )
  1833.     {    
  1834.         ODStorageUnit* su = session->GetClipboard(ev)->GetContentStorageUnit(ev);
  1835.         return su->Exists(ev, propertyName, type, 0);
  1836.     }
  1837.     else
  1838.     {
  1839.         return FALSE;
  1840.     }
  1841. }
  1842.  
  1843. //----------------------------------------------------------------------------------------
  1844. //    FW_CFrame::PrivContentViewLocationChanged
  1845. //----------------------------------------------------------------------------------------
  1846.  
  1847. void FW_CFrame::PrivContentViewLocationChanged(Environment* ev)
  1848. {
  1849.     FW_CAcquiredODTransform aqViewToFrameTransform = GetContentView(ev)->AcquireViewToFrameTransform(ev);
  1850.     aqViewToFrameTransform->GetOffset(ev, (ODPoint*)&fContentViewLocation);
  1851. }
  1852.  
  1853. //----------------------------------------------------------------------------------------
  1854. //    FW_CFrame::NewPrintHandler
  1855. //----------------------------------------------------------------------------------------
  1856.  
  1857. FW_CPrintHandler* FW_CFrame::NewPrintHandler(Environment* /* ev */)
  1858. {
  1859.     return NULL;
  1860. }
  1861.  
  1862. //----------------------------------------------------------------------------------------
  1863. //    FW_CFrame::IsCurrentlyPrintable
  1864. //----------------------------------------------------------------------------------------
  1865.  
  1866. FW_Boolean FW_CFrame::IsCurrentlyPrintable(Environment* /* ev */) const
  1867. {
  1868.     return TRUE;
  1869. }
  1870.  
  1871. //----------------------------------------------------------------------------------------
  1872. //    FW_CFrame::GetPrintContentExtent
  1873. //----------------------------------------------------------------------------------------
  1874.  
  1875. void FW_CFrame::GetPrintContentExtent(Environment* ev, FW_CPoint& extent) const
  1876. {
  1877.     GetContentExtent(ev, extent);
  1878.     FW_ASSERT(extent.x);
  1879.     FW_ASSERT(extent.y);
  1880. }
  1881.  
  1882. //----------------------------------------------------------------------------------------
  1883. //    FW_CFrame::GetPrintJobTitle
  1884. //----------------------------------------------------------------------------------------
  1885.  
  1886. void FW_CFrame::GetPrintJobTitle(Environment* ev, FW_CString& jobTitle) const
  1887. {
  1888.     GetPart(ev)->GetPartName(ev, jobTitle);
  1889. }
  1890.  
  1891. //========================================================================================
  1892. // CLASS FW_CScrollingViewIterator
  1893. //========================================================================================
  1894.  
  1895. //----------------------------------------------------------------------------------------
  1896. // FW_CScrollingViewIterator::FW_CScrollingViewIterator
  1897. //----------------------------------------------------------------------------------------
  1898.  
  1899. FW_CScrollingViewIterator::FW_CScrollingViewIterator(Environment* ev, const FW_CFrame *container) :
  1900.     fIterator(NULL)    
  1901. {
  1902.     if (container->fScrollingViews)
  1903.         fIterator = new FW_COrderedCollectionIterator(container->fScrollingViews);
  1904.  
  1905.     FW_END_CONSTRUCTOR
  1906. }
  1907.  
  1908. //----------------------------------------------------------------------------------------
  1909. // FW_CScrollingViewIterator::~FW_CScrollingViewIterator
  1910. //----------------------------------------------------------------------------------------
  1911.  
  1912. FW_CScrollingViewIterator::~FW_CScrollingViewIterator()
  1913. {
  1914.     FW_START_DESTRUCTOR
  1915.     
  1916.     delete fIterator;
  1917. }
  1918.